home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 July / macformat-026.iso / mac / Shareware City / Science / µSim 1.0 folder / source / DoMenu.c < prev    next >
Encoding:
Text File  |  1995-03-08  |  12.5 KB  |  537 lines  |  [TEXT/MMCC]
  1. /*
  2. Copyright © 1993,1994 by Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware: you can copy, exchange, modify this
  5. code as you wish. You may include this code in any kind of application: freeware,
  6. shareware, or commercial, provided that full credits are given.
  7. You may not sell or distribute this code for profit.
  8. */
  9.  
  10. //#pragma load "MacDump"
  11.  
  12. #include    "UtilsSys7.h"
  13. #include    "Globals.h"
  14. #include    "Animation.h"
  15. #include    "Assembler.h"
  16. #include    "ControlStore.h"
  17. #include    "Disasm.h"
  18. #include    "DoMenu.h"
  19. #include    "Dump.h"
  20. #include    "Input.h"
  21. #include    "Main.h"
  22. #include    "Microprogram_Ed.h"
  23. #include    "myMemory.h"
  24. #include    "Preferences.h"
  25. #include    "Registers.h"
  26. #include    "Simulator.h"
  27. #include    "SimUtils.h"
  28.  
  29. #if defined(FabSystem7orlater)
  30.  
  31. //#pragma segment Main
  32.  
  33. short lastCommand = kST_STOPPED;
  34.  
  35. static void DoMenuApple(short theItem);
  36. static void DoMenuEdit(short theItem);
  37. static void DoMenuMemory(short theItem);
  38. static void DoMenuRegs(short theItem);
  39. static void DoMenuHDisasm(short theItem);
  40. static void DoMenuHDump(short theItem);
  41. static void DoMenuControl(short theItem);
  42. static void CompletePreviousInstruction(void);
  43. static void DoMenuAssembler(short theItem);
  44.  
  45. void DoMenuApple(short theItem)
  46. {
  47. Str255    DAName;
  48.  
  49. if (theItem == kMItem_About__Simulato) {
  50. //    myAbout(DoIdle, nil, DoUpdate, DoActivate);
  51.     myMovableModalAbout(gPrefs.remembWind ? &gPrefs.aboutTL : nil,
  52.         gPrefs.remembWind ? &gPrefs.creditsTL : nil,
  53.         AdjustMenus,
  54.         Handle_My_Menu,
  55.         DomyKeyEvent,
  56.         DoUpdate,
  57.         DoActivate,
  58.         DoHighLevelEvent,
  59.         DoOSEvent,
  60.         DoIdle,
  61.         gSleep
  62.         );
  63.     UnloadSeg(myAbout);
  64.     }
  65. else {
  66.     AdjustMenus();
  67.     GetMenuItemText(gMenu_Apple, theItem, DAName);
  68.     (void)OpenDeskAcc(DAName);
  69.     }
  70. }
  71.  
  72. void DoMenuFile(short theItem)
  73. {
  74. register OSErr    err;
  75.  
  76. switch (theItem) {
  77.     case kMItem_New:
  78.         if (ReadyToTerminate()) {
  79.             DoNew();
  80.             UnloadSeg(DoNew);
  81.             DoMenuWindows(kMItem_Microprogram);
  82.             }
  83.         break;
  84.     case kMItem_Open_Control_St: {
  85.         StandardFileReply    mySFR;
  86.         SFTypeList    myTypeList;
  87.  
  88.         if (ReadyToTerminate()) {
  89.             myTypeList[0] = kFTY_CSTORE;
  90.             myTypeList[1] = kFTY_CSTOREPAD;
  91.             StandardGetFile(0L, 2, myTypeList, &mySFR);
  92.             if (mySFR.sfGood) {
  93.                 err = myOpenCSFile(&mySFR.sfFile, mySFR.sfScript,
  94.                                         (mySFR.sfFlags & kfIsStationery) != 0);
  95.                 UnloadSeg(myOpenCSFile);
  96.                 if (err)
  97.                     ErrorAlert(err);
  98.                 }
  99.             }
  100.         }
  101.         break;
  102.     case kMItem_Close:
  103.         (void)ReadyToTerminate();
  104.         break;
  105.     case kMItem_Save_Control_St:
  106.         err = mySaveCSFile(kGOT_SAVE);
  107.         UnloadSeg(mySaveCSFile);
  108.         if (err)
  109.             if (err != 1)
  110.                 ErrorAlert(err);
  111.         break;
  112.     case kMItem_Save_Control_St2:
  113.         err = mySaveCSFile(kGOT_SAVEAS);
  114.         UnloadSeg(mySaveCSFile);
  115.         if (err)
  116.             if (err != 1)
  117.                 ErrorAlert(err);
  118.         break;
  119.     case kMItem_Save_CS_Stationery:
  120.         err = mySaveCSFile(kGOT_SAVESTATIONERY);
  121.         UnloadSeg(mySaveCSFile);
  122.         if (err)
  123.             if (err != 1)
  124.                 ErrorAlert(err);
  125.         break;
  126.     case kMItem_Revert_to_Saved:
  127.         if (CautionAlert_UPP(kALRT_REVERT, myStdFilterProc) == ok) {
  128.             err = RevertFile();
  129.             UnloadSeg(RevertFile);
  130.             if (err)
  131.                 ErrorAlert(err);
  132.             }
  133.         break;
  134. /*    case kMItem_Page_Setup:
  135.         PageSetup();
  136.         UnloadSeg(PageSetup);
  137.         break;
  138.     case kMItem_Print:
  139.         Print_The_Data();
  140.         UnloadSeg(Print_The_Data);
  141.         break;*/
  142.     case kMItem_Prefs:
  143.         Preferences();
  144.         UnloadSeg(Preferences);
  145.         break;
  146.     case kMItem_Quit:
  147.         if (ReadyToTerminate())
  148.             gDoneFlag = true;
  149.         break;
  150.     }
  151. }
  152.  
  153. void DoMenuEdit(short theItem)
  154. {
  155. register Ptr    scPtr;
  156. register union u_mir *scanPtr;
  157. register union u_mir    tmpmir;
  158. register OSErr    err;
  159. register Byte    val;
  160.  
  161. if (SystemEdit(theItem - 1) == false) {
  162.     switch (theItem) {
  163. /* not implemented yet */
  164. //        case kMItem_Undo:
  165. //            break;
  166.         case kMItem_Cut:
  167.             if (gTheInput) {
  168.                 TECut(gTheInput);
  169.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  170.                     Microprog_TextWasModified();
  171.                 else if (gWPtr_IO == FrontWindow())
  172.                     AdjustScrollbars(gWPtr_IO, false);
  173.                 if ((err = ZeroScrap()) == noErr)
  174.                     err = TEToScrap();
  175.                 if (err)
  176.                     ErrorAlert(err);
  177.                 }
  178.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  179.                         (keyDownDest == kKEY_LIST))
  180.                 if (err = SendClipMsg(kCLIPMSG_CUT))
  181.                     ErrorAlert(err);
  182.             break;
  183.  
  184.         case kMItem_Copy:
  185.             if (gTheInput) {
  186.                 TECopy(gTheInput);
  187.                 if ((err = ZeroScrap()) == noErr)
  188.                     err = TEToScrap();
  189.                 if (err)
  190.                     ErrorAlert(err);
  191.                 }
  192.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  193.                         (keyDownDest == kKEY_LIST))
  194.                 if (err = SendClipMsg(kCLIPMSG_COPY))
  195.                     ErrorAlert(err);
  196.             break;
  197.  
  198.         case kMItem_Paste:
  199.             if (gTheInput) {
  200.                 TEPaste(gTheInput);
  201.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  202.                     Microprog_TextWasModified();
  203.                 else if (gWPtr_IO == FrontWindow())
  204.                     AdjustScrollbars(gWPtr_IO, false);
  205.                 }
  206.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  207.                         (keyDownDest == kKEY_LIST))
  208.                 if (err = SendClipMsg(kCLIPMSG_PASTE))
  209.                     ErrorAlert(err);
  210.             break;
  211.  
  212.         case kMItem_Clear:
  213.             if (gTheInput) {
  214.                 TEDelete(gTheInput);
  215.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  216.                     Microprog_TextWasModified();
  217.                 else if (gWPtr_IO == FrontWindow())
  218.                     AdjustScrollbars(gWPtr_IO, false);
  219.                 }
  220.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  221.                         (keyDownDest == kKEY_LIST))
  222.                 if (err = SendClipMsg(kCLIPMSG_CLEAR))
  223.                     ErrorAlert(err);
  224.             break;
  225.         case kMItem_Select_All:
  226.             if (gTheInput)
  227.                 TESetSelect(0, SHRT_MAX, gTheInput);
  228.             break;
  229.         case kMItem_Insert:
  230. //            LSetDrawingMode(false, Lists[kL_COMMENTS]);
  231.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  232.                 gCsMemory + theSelection[kL_COMMENTS] + 1,
  233.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS]));
  234.             gCsMemory[theSelection[kL_COMMENTS]].cstore = 0L;
  235.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  236.                     tmpmir = *scanPtr++)
  237.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  238.                     if (tmpmir.bits.addr != 0x7F) { /* WARNING: non-portable form */
  239.                         tmpmir.bits.addr++;
  240.                         *(scanPtr - 1) = tmpmir;
  241.                         }
  242.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  243.                 if (val >= theSelection[kL_COMMENTS]) {
  244.                     val++;
  245.                     *(scPtr - 1) = val;
  246.                     }
  247.             LDelRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  248.             LAddRow(1, theSelection[kL_COMMENTS]++, Lists[kL_COMMENTS]);
  249.             DocumentIsDirty(true);
  250. //            LSetDrawingMode(true, Lists[kL_COMMENTS]);
  251.             LAutoScroll(Lists[kL_COMMENTS]);
  252.             break;
  253.         case kMItem_Delete:
  254. //            LSetDrawingMode(false, Lists[kL_COMMENTS]);
  255.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  256.                     tmpmir = *scanPtr++)
  257.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  258.                     if (tmpmir.bits.addr) {
  259.                         tmpmir.bits.addr--;
  260.                         *(scanPtr - 1) = tmpmir;
  261.                         }
  262.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  263.                 if (val > theSelection[kL_COMMENTS]) {
  264.                     val--;
  265.                     *(scPtr - 1) = val;
  266.                     }
  267.             SelectLLine(kL_COMMENTS, theSelection[kL_COMMENTS] + 1);
  268.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  269.                 gCsMemory + theSelection[kL_COMMENTS] - 1,
  270.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS] + 1));
  271.             gCsMemory[maxLLine[kL_COMMENTS]].cstore = 0L;
  272.             LDelRow(1, --theSelection[kL_COMMENTS], Lists[kL_COMMENTS]);
  273.             LAddRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  274.             DocumentIsDirty(true);
  275. //            LSetDrawingMode(true, Lists[kL_COMMENTS]);
  276.             LAutoScroll(Lists[kL_COMMENTS]);
  277.             break;
  278.         case kMItem_CopyEmailAddr:
  279.             CopyEMailAddrToClip();
  280.             break;
  281.         case kMItem_CopyWWWURL:
  282.             CopyWWWURLToClip();
  283.             break;
  284.         }
  285.     }
  286. }
  287.  
  288. void DoMenuWindows(short theItem)
  289. {
  290. register WindowPtr    wind;
  291.  
  292. switch (theItem) {
  293.     case kMItem_Animation:
  294.         wind = gWPtr_Animation;
  295.         break;
  296.     case kMItem_Registers:
  297.         wind = gWPtr_Registers;
  298.         break;
  299.     case kMItem_IO:
  300.         wind = gWPtr_IO;
  301.         break;
  302.     case kMItem_Microprogram:
  303.         PrepareOpenMicroprogram();
  304.         wind = gWPtr_Microprogram_Ed;
  305.         break;
  306.     case kMItem_Disasm:
  307.         wind = gWPtr_Disasm;
  308.         break;
  309.     case kMItem_Dump:
  310.         wind = gWPtr_Dump;
  311.         break;
  312.     }
  313. ShowWindowAndCheckMenu(wind, theItem);
  314. SelectWindow(wind);
  315. }
  316.  
  317. void ShowWindowAndCheckMenu(WindowPtr w, short theMenuItem)
  318. {
  319. if (((WindowPeek)w)->visible == false) {
  320.     CheckItem(gMenu_Windows, theMenuItem, true);
  321.     SetPort(w);
  322.     ShowWindow(w);
  323.     }
  324. }
  325.  
  326. void DoMenuMemory(short theItem)
  327. {
  328. register OSErr    err;
  329.  
  330. switch (theItem) {
  331.     case kMItem_Open: {
  332.         StandardFileReply    mySFR;
  333.         SFTypeList    myTypeList;
  334.  
  335.         myTypeList[0] = kFTY_RAM;
  336.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  337.         if (mySFR.sfGood) {
  338.             if (err = myOpenFile(&mySFR.sfFile, gMMemory, kSIZE_RAM))
  339.                 ErrorAlert(err);
  340.             UnloadSeg(myOpenFile);
  341.             }
  342.         }
  343.         break;
  344.     case kMItem_Save_As:
  345.         if (err = mySaveFile(gMMemory, kSIZE_RAM, kFTY_RAM, kSTR_RAMPROMPT, kSTR_RAMDEFNAME))
  346.             ErrorAlert(err);
  347.         UnloadSeg(mySaveFile);
  348.         break;
  349.     }
  350. }
  351.  
  352. void    DoMenuRegs(short theItem)
  353. {
  354. register OSErr    err;
  355.  
  356. switch (theItem) {
  357.     case kMItem_Open: {
  358.         StandardFileReply    mySFR;
  359.         SFTypeList    myTypeList;
  360.  
  361.         myTypeList[0] = kFTY_REG;
  362.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  363.         if (mySFR.sfGood) {
  364.             if (err = OpenProcessorState(&mySFR.sfFile))
  365.                 ErrorAlert(err);
  366.             UnloadSeg(OpenProcessorState);
  367.             }
  368.         }
  369.         break;
  370.     case kMItem_Save_As:
  371.         if (err = SaveProcessorState())
  372.             ErrorAlert(err);
  373.         UnloadSeg(SaveProcessorState);
  374.         break;
  375.     }
  376. }
  377.  
  378. static void    DoMenuHDisasm(short theItem)
  379. {
  380. SetControlValue(disasmVScroll, (unsigned short)gRegs[theItem - 1] >> 1);
  381. InvalDisasm();
  382. }
  383.  
  384. static void    DoMenuHDump(short theItem)
  385. {
  386. SetControlValue(dumpVScroll, (unsigned short)gRegs[theItem - 1] >> 3);
  387. InvalDump();
  388. }
  389.  
  390. /* da schiaffare dentro la routine successiva */
  391. const short toDeact[] = {    kP_MPC2INC, kP_INCR, kP_MPC2CST, kP_CST2MIR,
  392.                             kP_REG2LTCH1, kP_REG2LTCH2, kP_ALATCH, kP_BLATCH,
  393.                             kP_AMUX2ALU, kP_BLTCH2ALU, kP_ALU, kP_ALU2SH,
  394.                             kP_SHIFTER, kP_SH2REGS1, kP_SH2REGS2, kP_SH2REGS3,
  395.                             kP_MAR, kP_BLTCH2MAR1, kP_BLTCH2MAR2,
  396.                             kP_MBR, kP_SH2MBR1, kP_SH2MBR2, kP_MAP, kP_MAPREGS,
  397.                             kP_ALTCH2AMUX, kP_AMUX, kP_MBR2AMUX,
  398.                             kP_INC2MMUX1, kP_INC2MMUX2, kP_MMUX, kP_MPC,
  399.                             kC_ADDR1, kC_ADDR2, kP_MMUX2MPC, 0 };
  400.  
  401. void DoMenuControl(short theItem)
  402. {
  403. short lastCommand = kST_STOPPED;
  404. register OSErr    err;
  405.  
  406. switch (theItem) {
  407.     case kMItem_Go:
  408.         gRstatus = kST_GOING;
  409.         CompletePreviousInstruction();
  410.         lastCommand = kST_GOING;
  411.         break;
  412.     case kMItem_Stop:
  413.         StopIt();
  414.         lastCommand = kST_STOPPED;
  415.         break;
  416.     case kMItem_StepSub:
  417.         gRstatus = kST_STEPSUBCYC;
  418.         if (lastCommand != kST_STEPSUBCYC) {
  419.             DeactivateObjs(toDeact);
  420.             lastCommand = kST_STEPSUBCYC;
  421.             }
  422.         break;
  423.     case kMItem_StepMicro:
  424.         gRstatus = kST_STEPMPROG;
  425.         lastCommand = kST_STEPMPROG;
  426.         break;
  427.     case kMItem_StepInstr:
  428.         gRstatus = kST_STEPASM;
  429.         CompletePreviousInstruction();
  430.         lastCommand = kST_STEPASM;
  431.         break;
  432.     case kMItem_ResetMem:
  433.         if ((err = CautionAlert_UPP(kALRT_RESETMEM, myStdFilterProc)) == ok) {
  434.             MyZeroBuffer((long *)gMMemory, numOfLongs(kSIZE_RAM));
  435.             ResetMemory();
  436.             InvalDump();
  437.             InvalDisasm();
  438.             }
  439.         break;
  440.     case kMItem_ResetRegs:
  441.         if ((err = CautionAlert_UPP(kALRT_RESETREGS, myStdFilterProc)) == ok) {
  442.             ResetRegisters();
  443.             UnloadSeg(ResetRegisters);
  444.             ChangedRegister(kREG_PC);
  445.             ChangedRegister(kREG_SP);
  446.             ChangedBox(kP_MPC - kFIRST_PICT);
  447.             }
  448.         break;
  449.     case kMItem_SelectCurMPC:
  450.         SelectLLine(kL_COMMENTS, gParts[kP_MPC - kFIRST_PICT]);
  451.         DoMenuWindows(kMItem_Microprogram);
  452.         break;
  453.     }
  454. }
  455.  
  456. /* CompletePreviousInstruction: keeps in sync the processor when
  457. alternating different step modes with continuous execution */
  458.  
  459. static void CompletePreviousInstruction(void)
  460. {
  461. while (gSubclk) {
  462.     ExecuteInstructions(gSubclk++);
  463.     gSubclk &= 3;
  464.     }
  465. }
  466.  
  467. void DoMenuAssembler(short theItem)
  468. {
  469. register OSErr    err;
  470.  
  471. switch (theItem) {
  472.     case kMItem_Assemble_file: {
  473.         StandardFileReply    mySFR;
  474.         SFTypeList    myTypeList;
  475.  
  476.         myTypeList[0] = 'TEXT';
  477.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  478.         if (mySFR.sfGood) {
  479.             if (err = myAsmFile(&mySFR.sfFile))
  480.                 ErrorAlert(err);
  481.             UnloadSeg(myAsmFile);
  482.             }
  483.         }
  484.         break;
  485.     case kMItem_AsmPrefs:
  486.         DoAsmPrefsDialog();
  487.         UnloadSeg(DoAsmPrefsDialog);
  488.         break;
  489.     }
  490. }
  491.  
  492. void Handle_My_Menu(long myMenu)
  493. {
  494. register short    theMenu, theItem;
  495.  
  496. theMenu = HiWrd(myMenu);
  497. if (theMenu) {
  498.     theItem = LoWrd(myMenu);
  499.     switch (theMenu) {
  500.         case kRes_Menu_HMemory:
  501.             DoMenuMemory(theItem);
  502.             break;
  503.         case kRes_Menu_HRegs:
  504.             DoMenuRegs(theItem);
  505.             break;
  506.         case kRes_Menu_HDisasm:
  507.             DoMenuHDisasm(theItem);
  508.             break;
  509.         case kRes_Menu_HDump:
  510.             DoMenuHDump(theItem);
  511.             break;
  512.         case kRes_Menu_Apple:
  513.             DoMenuApple(theItem);
  514.             break;
  515.         case kRes_Menu_File:
  516.             DoMenuFile(theItem);
  517.             break;
  518.         case kRes_Menu_Edit:
  519.             DoMenuEdit(theItem);
  520.             break;
  521.         case kRes_Menu_Windows:
  522.             DoMenuWindows(theItem);
  523.             break;
  524.         case kRes_Menu_Control:
  525.             DoMenuControl(theItem);
  526.             break;
  527.         case kRes_Menu_Assembler:
  528.             DoMenuAssembler(theItem);
  529.             break;
  530.         }
  531.     }
  532. HiliteMenu(0);
  533. }
  534.  
  535. #endif
  536.  
  537.